package com.solution.admin.settings.service.impl;

import java.util.HashMap;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.solution.admin.settings.dao.SortDao;
import com.solution.admin.settings.entity.SortEntity;
import com.solution.admin.settings.service.SortService;
import com.solution.common.dao.BaseDao;
import com.solution.common.service.impl.BaseServiceImpl;
import com.solution.common.utils.string.StringUtil;

@Service
public class SortServiceImpl extends BaseServiceImpl<SortEntity> implements SortService {
	
	/**
	 * 默认初始排序号
	 */
	static final int DEFAULT_SORT_NO = 1000000;
	
	@Autowired
	private SortDao sortDao;
	
	protected BaseDao<SortEntity> getDao() {
		return this.sortDao;
	}
	
	/**
	 * 返回最大排序号
	 * @param tableName
	 * @return int    
	 * @author xu_cc  
	 * @throws Exception exception
	 * @Date 创建时间：2018年3月12日 下午7:49:40
	 */
	public int getMaxSortNo(String tableName) {
		try {
			int sortNo = sortDao.getMaxSortNo(tableName);
			return sortNo + 1;
        } catch (Exception e) {
        	e.printStackTrace();
        	return DEFAULT_SORT_NO;
        }
	}
	
	/**
	 * 返回一个置顶的排序好
	 * 
	 * @param tableName
	 * @return Integer
	 * @author xu_cc
	 * @throws Exception
	 *             exception
	 * @Date 创建时间：2018年1月11日 下午2:56:29
	 */
	public int getFirstSortNo(String tableName) {
		try {
			SortEntity sortEntity = new SortEntity();
			sortEntity.setTableName(tableName);
			SortEntity firtSort = sortDao.getFirstSortNo(sortEntity);
			if (null != firtSort) {
				return firtSort.getSortNo() - 1;
			} else {
				// 取不到数据，有可能从未有数据，那就给一个初始值
				return DEFAULT_SORT_NO;
			}
		} catch (Exception e) {
			e.printStackTrace();
			return DEFAULT_SORT_NO;
		}
	}
	
	/**
	 * @param direction 排序方向  -1 上移  1 下移 0 置顶 100最后
	 * @param id
	 * @param tableName 表名称
	 * @return
	 * @author: solin
	 * @date: 2017年9月18日 下午10:50:11
	 */
	@Override
	public int sort(String direction, String tableName, long id, String parentColumnName, Long parentId){
		int res = 0;
		Map<String, Object> mapParam = new HashMap<String, Object>();
		mapParam.put("tableName", tableName);
		mapParam.put("id", id);
		if (StringUtil.isNotEmpty(parentColumnName) && null != parentId) {
			mapParam.put("parentColumnName", parentColumnName);
			mapParam.put("parentId", parentId);
		}
		SortEntity currentSortEntity = sortDao.getCurrentById(mapParam);
		if (null != currentSortEntity) {
			currentSortEntity.setParentColumnName(parentColumnName);
			currentSortEntity.setParentId(parentId);
		}
		return sort(direction, tableName, currentSortEntity);
	}
	
	/**
	 * @param direction 排序方向  -1 上移  1 下移 0 置顶 100最后
	 * @param currentSortEntity
	 * @param tableName 表名称
	 * @return
	 * @author: solin
	 * @date: 2017年9月18日 下午10:50:11
	 */
	@Override
	public int sort(String direction, String tableName, SortEntity currentSortEntity){
		int res = 0;
		currentSortEntity.setTableName(tableName);
		if ("0".equals(direction)) { //置顶
			//获取排第一个的数据
			SortEntity firtSortEntity = sortDao.getFirstSortNo(currentSortEntity);
			//更新当前行的序号
			currentSortEntity.setSortNo(firtSortEntity.getSortNo() - 1);
			res = sortDao.update(currentSortEntity);
		} else if ("-1".equals(direction)) { //下移
			//获取下一个数据
			SortEntity nextSortEntity = sortDao.getNextBySortNo(currentSortEntity);
			if (null == nextSortEntity) {
				return 0;
			}
			int currentSortNo = currentSortEntity.getSortNo();
			int nextSortNo = nextSortEntity.getSortNo();
			//交换序号
			currentSortEntity.setSortNo(nextSortNo);
			res = sortDao.update(currentSortEntity);
			
			nextSortEntity.setSortNo(currentSortNo);
			nextSortEntity.setTableName(tableName);
			res = res * sortDao.update(nextSortEntity);
		} else if ("1".equals(direction)) { //上移
			//获取上一个数据
			SortEntity previousSortEntity = sortDao.getPreviousBySortNo(currentSortEntity);
			if (null == previousSortEntity) {
				return 0;
			}
			int currentSortNo = currentSortEntity.getSortNo();
			int previousSortNo = previousSortEntity.getSortNo();
			//交换序号
			currentSortEntity.setSortNo(previousSortNo);
			res = sortDao.update(currentSortEntity);
			
			previousSortEntity.setSortNo(currentSortNo);
			previousSortEntity.setTableName(tableName);
			res = res * sortDao.update(previousSortEntity);
		} else if ("100".equals(direction)) { //移到最尾（给最大的排序号）
			//获取排第一个的数据
			int sortNo = sortDao.getMaxSortNo(tableName);
			//更新当前行的序号
			currentSortEntity.setSortNo(sortNo + 1);
			res = sortDao.update(currentSortEntity);
		}
		return res;
	}

}
